package com.erp.erp_ui.Billing.Controller;

import com.alibaba.fastjson.JSONObject;
import com.erp.erp_entitys.Billing.req.*;
import com.erp.erp_entitys.Billing.vo.*;
import com.erp.erp_entitys.Cost.vo.NameAndCodeVO;
import com.erp.erp_entitys.Cost.vo.QueryImportContractVO;
import com.erp.erp_entitys.User.UserEntity;
import com.erp.erp_servers.Billing.BillingService;
import com.erp.erp_ui.Billing.Service.BillingAllService;
import com.erp.erp_ui.Billing.Service.MergeBillingVO;
import com.erp.erp_ui.base.Base;
import com.erp.utils.R;
import com.erp.utils.ResultStatusEnum;
import com.github.pagehelper.PageInfo;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @author zjk
 * @version 1.0
 * @description 开票
 * @date 2021/1/16/016 21:59
 */
@Controller
@RequestMapping("billing")
public class BillingController extends Base {
    /**
     * 日志
     */
    private static final Logger log= LoggerFactory.getLogger(BillingController.class);

    private final BillingService billingService;
    private final BillingAllService billingAllService;

    public BillingController(BillingService billingService, BillingAllService billingAllService){
        this.billingService=billingService;
        this.billingAllService = billingAllService;
    }


    /**
     * 查询所有供应商
     * @return
     */
    @GetMapping("findAllCustomer2")
    @ResponseBody
    public R findAllCustomer2(){
        try {
            log.info("开票->准备获取所有供应商");
            List<CompanyVO> companyVOList=billingService.findAllCustomer2();
            return R.build(companyVOList);

        } catch (Exception e) {
            log.error("开票->获取所有供应商功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }
    /**
     * 查询所有签约公司
     * @return
     */
    @GetMapping("findAllCompany")
    @ResponseBody
    public R findAllCompany(){
        try {
            log.info("开票->准备获取所有签约公司");
            List<CompanyVO> companyVOList=billingService.findAllCompany();
            return R.build(companyVOList);

        } catch (Exception e) {
            log.error("开票->获取所有签约公司功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 查询银行集合
     * @return
     */
    @GetMapping("getAllBankName")
    @ResponseBody
    public R getAllBankName(){
        try {
            log.info("开票->准备查询银行集合");
            List<String> bankNameList=billingService.getBankName(null);
            return R.build(bankNameList);

        } catch (Exception e) {
            log.error("开票->查询银行集合功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 根据签约公司编号查询银行集合
     * @return
     */
    @PostMapping("getBankName")
    @ResponseBody
    public R getBankName(@RequestBody String billingTowerHeadCode){
        try {
            log.info("开票->准备根据签约公司编号查询银行集合");
            List<String> bankNameList=billingService.getBankName(billingTowerHeadCode);
            return R.build(bankNameList);

        } catch (Exception e) {
            log.error("开票->根据签约公司编号查询银行集合功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }


    /**
     * 修改，添加开票信息
     * @return
     */
    @PostMapping("add/register")
    @ResponseBody
    public R add(@RequestBody InsertBillingReq reqData){
        try {
            log.info("开票->添加开票信息");
            boolean flag=billingAllService.add(reqData);
            if (flag){
                return R.build(ResultStatusEnum.SUCCESS);
            }
            return R.build(ResultStatusEnum.PARAMETER_ERROR);
        } catch (Exception e) {
            log.error("开票->添加开票信息功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 根据签约公司获取银行名称-开票用，
     * @param companyCode
     * @return
     */
    @GetMapping("getBankNameByCompanyCode")
    @ResponseBody
    public R getBankNameByCompanyCode(String companyCode){
        try {
            log.info("开票->根据签约公司获取银行名称-开票用");
            String bankName=billingService.getBankNameByCompanyCode(companyCode);
            if (StringUtils.isEmpty(bankName)){
                return R.build("");
            }
            return R.build(bankName);

        } catch (Exception e) {
            log.error("开票->根据签约公司获取银行名称-开票用功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }
    //获得编号
    @GetMapping("getBillingCode")
    @ResponseBody
    public R getBillingCode(){
        try {
            log.info("开票->准备获取编号");
            String code=billingService.selectCodeByCode();
            return R.build(code);

        } catch (Exception e) {
            log.error("开票->获取编号功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }
    /**
     * 获取登陆用户信息
     * @return 登陆用户信息
     */
    @GetMapping("/getLoginUserInfo")
    @ResponseBody
    public R getLoginUserInfo(){
        log.info("资金管理-开票-获取登陆用户信息");
        try {
            UserEntity user = (UserEntity)this.getBean("user");
            return R.build(user);
        }catch (Exception e){
            log.info("资金管理-开票-获取登陆用户信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }


    //********************************


    /**
     * 根据条件获取报关信息
     * @param req
     * @return
     */
    @RequestMapping("getBillDeclareInfoListByPage")
    @ResponseBody
    public R getBillDeclareInfoByPage(QueryBillDeclareReq req){
        log.info("资金管理-开票-获取报关信息");
        try {
            PageInfo<QueryBillDeclareVO2> pageInfo=billingService.selectBillDeclare2ByPage(req);
            return R.build(0,"", pageInfo.getTotal(), pageInfo.getList());
        }catch (Exception e){
            log.info("资金管理-开票-获取报关信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取报关明细
     * @param declareId 销售合同id
     * @return 报关明细集合
     */
    @GetMapping("getBillDeclareProductInfoListByPage")
    @ResponseBody
    public R getBillDeclareProductInfoListByPage(Integer declareId,String manufacturerName,String invoiceCode){
        try {
            log.info("资金管理-开票-获取报关明细");
            if(null == declareId){
                return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
            }

            PageInfo<QueryBillDeclareDetailVO> pageInfo=billingAllService.findBillDeclareDetailByPage(declareId,manufacturerName,invoiceCode);

            return R.build(0,"", pageInfo.getTotal(), pageInfo.getList());
        }catch (Exception e){
            log.info("资金管理-开票-获取报关明细信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }
    /**
     * 根据采购主表ID查询采购产品信息
     * @param purchaseId 采购id
     * @return 采购产品集合
     */
    @GetMapping("getPurchaseProductList")
    @ResponseBody
    public R getPurchaseProductList(Integer purchaseId){
        try {
            log.info("资金管理-开票-根据采购主表ID查询采购产品信息");
            if(null == purchaseId){
                return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
            }
            List<QueryPurchaseProductVO> purchaseProductVOList=billingAllService.selectPurchaseProductByPurchaseId(purchaseId);

            return R.build(purchaseProductVOList);
        }catch (Exception e){
            log.info("资金管理-开票-根据采购主表ID查询采购产品信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }



    /**
     * 根据条件查询开票信息
     * @return
     */
    @RequestMapping("findBillingListByPage")
    @ResponseBody
    public R findBillingListByPage(QueryBillingReq req){
        try {
            log.info("开票->准备根据签约公司编号查询银行集合");
            PageInfo<QueryBillingVO> pageInfo=billingService.findBillingList(req);
            return R.build(0,"", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            log.error("开票->根据签约公司编号查询银行集合功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }


    /**
     * 删除开票
     * @param ids
     * @return
     */
    @PostMapping("updateBillingValidById")
    @ResponseBody
    public R updateBillingValidById(@RequestBody Integer[] ids){
        try {
            log.info("删除开票,id:{}",ids);
            billingAllService.updateBillingAndDetailValidById(ids);
            return R.build(ResultStatusEnum.SUCCESS);
        } catch (Exception e) {
            log.error("费用->删除开票功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }
    /**
     * 修改开票状态
     * @param id
     * @param status
     * @return
     */
    @PostMapping("updateBillingStatusById")
    @ResponseBody
    public R updateBillingStatusById(Integer id,Integer status){
        try {
            log.info("修改开票状态");
            return billingService.updateBillingStatusById(id,status);
        } catch (Exception e) {
            log.error("费用->修改开票状态功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }
    /**
     * 根据开票id查询开票，开票明细，附件。信息
     * @param id
     * @return
     */
    @PostMapping("findAllBillingById")
    @ResponseBody
    public R findAllBillingById(@RequestBody Integer id){
        try {
            log.info("根据开票id查询开票，开票明细，附件。信息");
            MergeBillingVO mergeBilling=billingAllService.findAllBillingById(id);
            return R.build(mergeBilling);
        } catch (Exception e) {
            log.error("费用->根据开票id查询开票，开票明细，附件。信息功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取当前月开票的记录数
     * @param startCreateDate
     * @param endCreateDate
     * @return
     */
    @RequestMapping("findBillingSize")
    @ResponseBody
    public R findBillingSize(String startCreateDate,String endCreateDate){
        try {
            log.info("根据开票id查询开票，开票明细，附件。信息");
            QueryBillingReq req=new QueryBillingReq();
            req.setStartCreateDate(startCreateDate);
            req.setEndCreateDate(endCreateDate);
            List<QueryBillingVO> list=billingService.findBillingListByMouth(req);
            return R.build(list.size());

        } catch (Exception e) {
            log.error("费用->根据开票id查询开票，开票明细，附件。信息功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }


    /**
     * 供应商开票统计-分页
     * @return
     */
    @RequestMapping("billingStatistics1ListByPage")
    @ResponseBody
    public R billingStatistics1ListByPage(billingStatistics1Req req){
        try {
            log.info("开票->准备开票情况统计");
            PageInfo<billingStatistics1VO> pageInfo=billingAllService.billingStatistics1List(req);
            return R.build(0,"", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            log.error("开票->开票情况统计功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 供应商开票统计--导出
     * @return
     */
    @RequestMapping("billingStatistics1Export")
    @ResponseBody
    public R billingStatistics1Export(billingStatistics1Req req){
        try {
            log.info("开票->准备开票情况统计");
            JSONObject info= billingAllService.billingStatistics1Export(req);
            return R.build(info);
        } catch (Exception e) {
            log.error("开票->开票情况统计功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }


    /**
     * 采购开票统计-分页
     * @return
     */
    @RequestMapping("billingPurchaseStatisticsListByPage")
    @ResponseBody
    public R billingPurchaseStatisticsListByPage(BillingPurchaseStatisticsReq req){
        try {
            log.info("开票->采购开票统计 req="+req);
            PageInfo<BillingPurchaseStatisticsRes> pageInfo=billingAllService.billingPurchaseStatisticsPage(req);
            return R.build(0,"", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            log.error("开票->采购开票统计功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }
    /**
     * 采购开票统计--导出
     * @return
     */
    @RequestMapping("billingPurchaseStatisticsExport")
    @ResponseBody
    public R billingPurchaseStatisticsExport(BillingPurchaseStatisticsReq req){
        try {
            log.info("开票->采购开票统计 req="+req);
            JSONObject info= billingAllService.billingPurchaseStatisticsExport(req);
            return R.build(info);
        } catch (Exception e) {
            log.error("开票->采购开票统计功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }



    /**
     * 获取外销合同--开票用
     * @return
     */
    @RequestMapping("getExportContentListByPage")
    @ResponseBody
    public R getExportContent(QueryImportExportContractReq req){
        try {
            log.info("开票->获取外销合同--开票用");
            PageInfo<QueryImportContractVO> pageInfo=billingAllService.getExportContentListByPage(req);
            return R.build(0,"", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            log.error("开票->获取外销合同--开票用 功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取价格术语，只包含国内的--开票用
     * @return
     */
    @GetMapping("getPriceTerms")
    @ResponseBody
    public R getPriceTerms(){
        try {
            log.info("开票->获取价格术语，只包含国内的--开票用");
            List<NameAndCodeVO> list=billingAllService.getPriceTerms();
            return R.build(list);
        } catch (Exception e) {
            log.error("开票->获取价格术语，只包含国内的--开票用 功能异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 根据外销合同号 查询外销产品信息
     * @param exportContractNo 外销合同号
     */
    @RequestMapping("getExportContractProductList")
    @ResponseBody
    public R getExportContractProductList(String exportContractNo){
        try {
            log.info("资金管理-开票-根据外销合同号 查询外销产品信息");
            if(StringUtils.isEmpty(exportContractNo)){
                return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
            }

            List<QueryExportProductVO> purchaseProductVOList=billingAllService.selectExportProductByPurchaseId(exportContractNo);
            return R.build(purchaseProductVOList);

        }catch (Exception e){
            log.info("资金管理-开票-根据外销合同号 查询外销产品信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 查询符合开票的结汇产品信息
     * @param invoiceNo 发票编号
     * @param billId 结汇ID
     * @return
     */
    @RequestMapping("getBillExchangeProductList")
    @ResponseBody
    public R getBillExchangeProductList(String invoiceNo,Integer billId){
        try {
            log.info("资金管理-开票-查询符合开票的结汇产品信息");
            if(StringUtils.isEmpty(invoiceNo) && billId == null){
                return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
            }
            List<QueryExportProductVO> purchaseProductVOList=billingAllService.selectBillExchangeProductByParam(invoiceNo,billId);
            return R.build(purchaseProductVOList);

        }catch (Exception e){
            log.info("资金管理-开票-根据外销合同号 查询外销产品信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }


    /**
     * 开票-导入采购合同
     * @param req
     * @return
     */
    @RequestMapping("getPurchaseContractListByPage")
    @ResponseBody
    public R getPurchaseContract(QueryPurchaseContractReq req){
        try {

            log.info("开票-导入采购合同");
            PageInfo<QueryPurchaseContractVO>  pageInfo=billingAllService.getPurchaseContractListByPage(req);
            return R.build(0,"",pageInfo.getTotal(),pageInfo.getList());

        } catch (Exception e) {
            log.error("费用->开票-导入采购合同异常",e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }


    /**
     * 获取符合开票的出运明细产品信息  出运明细有两个  供应商开票  客户开票
     */
    @GetMapping("getCarryDetailProductListByPage")
    @ResponseBody
    public R getCarryDetailProductList(QueryImportCarrDetailProductReq req){
        try {
            log.info("资金管理-开票-获取符合开票的出运明细产品信息");
            PageInfo<QueryImportCarrDetailProductRes> pageInfo=billingAllService.findCarryDetailProductList(req);
            return R.build(0,"",pageInfo.getTotal(),pageInfo.getList());
        }catch (Exception e){
            log.info("资金管理-开票-获取符合开票的出运明细产品信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }


}
